Software capabilities and requirements are rapidly advancing in the present field of computer technology. Companies all over the world desire robust and versatile software solutions to help their businesses expand and excel. However, in spite of overwhelming demand, many companies find that the available software solutions are limited in selection, and that the software solutions are generally developed to support only one programming platform. Accordingly, many companies are struggling with a wide variety of choices for client platforms, transaction servers, and data base systems, while at the same time facing the challenge of integrating them all into one working solution. In general, software applications interact with objects, which are a collection of procedures defining a procedural logic of the application. It is desired that these objects can be used by multiple applications and systems, however this ability is typically limited because objects tend to be designed as platform specific. Accordingly, an object designed for one application that functions on one platform may not be easily accessible by another software application written for a different platform. Therefore, this limitation has made the sharing of objects across different systems and platforms difficult, thus making the sharing objects over an Internet environment problematic.
In the past, many programming languages and applications have been developed for use in computation. Early languages were often very closely tied to the physical hardware of the device being programmed. As the complexity of software grew, it became advantageous to develop systems which abstracted away most of this complexity from the user. Accordingly, the need for adaptability in software applications has intensified in the past few years, as a result of the growth of the Internet, from a large number of companies attempting to extend their business practices to the World Wide Web. Companies of today are concerned with providing highly distributed software applications that are fully accessible over the Internet. Accordingly, users of the company services expect to access their data from any number of devices such as wireless hand held devices, web browsers, and their desktops, regardless of the operating system they are implementing. Accordingly, software programmers today must often develop and customize the same application several times in a variety languages to work in these different environments. Attempts have been made to run the same program somewhat modified for different platforms, however this typically results in a poor output as the code is not optimized to the constraints of each and every target machine to which it is applied. For example, the desire to run a rich desk top application but on a light weight hand held device.
A further problem is that many companies wish to adapt their existing software systems, such as Legacy applications with character based interfaces and hardware, to scalable Internet enabled modem systems. Accordingly, shifting from Legacy based applications typically involves choosing between continuing to develop new code on an expensive antiquated system, or getting rid of existing equipment and purchasing new adaptable hardware and corresponding software applications.
In view of the above discussed application constraints, there have been several approaches in the past used to simplify application development for multiple platforms. The earliest attempts were centered around a preprocessor, which is a straight forward device that takes an input file written in a specific software language, containing not only language specific statements but also preprocessor directives. The directives helped the user to create macros or short hand phrases which represented more complicated constructs. In turn, more complicated directives were developed to allow the porting of applications from one computer system to another. However, the main draw back to preprocessors is that the source code is interspersed with preprocessor directives, which becomes more complicated to read. In addition, the underlying complexities of the different platforms, while dealt with, are no way hidden from the user, thereby requiring the user to determine which portions of their code must be modified for the various selected platforms. This can be a labor intensive and accordingly costly procedure.
A second generation of software tools was developed to isolate the user from details of the underlying architecture. The second generation tools were more intelligent allowing the user to specify segments of their code in a language independent format. The source code was then passed through a preprocessor where dependent code was added to the source file, examples of which include SQL pre-compilers. However, pre-compilers are generally limited to a section of the source code which is capable of being written in the independent format. This process helps to remove the underlying details of language specific libraries but does not substantially reduce the volume of code necessary to write a given application.
A further attempted solution to the transport of an application to multiple platforms is translators. Many translation routines exist which allow one language to be converted to another, which fall into the two broad categories of natural language systems and artificial language systems. However, in natural language systems exact translation can be difficult to obtain and therefore probabilities and pattern matching must be used. Although, this approach is unacceptable for computer languages as the translations must be deterministic and accurate. Accordingly, artificial language systems have focused on translation from one known language to another by a well understood medium. The construction of translators, so that language specific code is modularized and reusable, is generally accomplished by parsing the input program and constructing a single or series of abstract syntax trees. The syntax trees represent a language independent view of the operations at a low level. The translation process involves first manipulation of this representation and then reversal of the process, which is generating the translated code from the syntax tree. One example of this process is taught by U.S. Pat. No. 6,031,993 by Andrews et al. This patent describes a method, system, and apparatus for translating one computer language to another using a doubly routed tree data structure. The structure is a combination of two sets of hierarchical related objects sharing a common set of leaves. The object of the patent is to provide a method and apparatus for automatically translating the source code from one high level computer language to the source code of another language. However, the construction of the routed tree structures is performed on a source code by source code basis. This can be a relatively expensive approach as the code must be broken down and then re-assembled. A second disadvantage is that it is difficult for humans in understanding the abstract representation, wherein the interpretation of a single line of code could involve numerous nodes.
A more recent approach to solving portability concerns has been the advent of virtual machine based architecture, wherein virtual instructions are executed by converting them into real instructions which can be executed on the actual machine. Several such architecture exist today, from interpreting bit codes at a hardware level to application servers which dynamically re-interpret their source documents depending upon the calling process requirements. However, one disadvantage to these interpretative systems is that substantial performance penalties are imposed by them as each time the system is accessed, the translation of the calls must be done anew. This has to a certain extent been mitigated by the use of cashing architectures but performance penalties still remain.
It is an object of the present invention to obviate or mitigate some of the above presented disadvantages.